home *** CD-ROM | disk | FTP | other *** search
/ Disc to the Future 2 / Disc to the Future Part II Programmer's Reference (Wayzata Technology)(6013)(1992).bin / MAC / THINKC / 3_0 / SPIRO_SO / FTRIG.C < prev    next >
Text File  |  1989-06-06  |  3KB  |  87 lines
  1. /*        FTRIG.C
  2. **    This is a function that can be used to speed up sine/cosine 
  3. **  calculations.  It stores the values for sine from 0 - 90 degrees,
  4. **  and lets you get at them by table look up, rather than by infinite
  5. **  series floating point operations.  (infinite is a relative word,
  6. **  of course)  First used in a program that simulates spirograph, which
  7. **  requires lots of sine/cos calculations.  The whole thing was getting
  8. **  my little Mac Plus down, so I wrote this.
  9. **
  10. **        To use it:  The first call should be with the FTRIG_INIT function,
  11. **    which actually stores all the sine values. Then you can use FTRIG_SINE 
  12. **    and FTRIG_COS to get sine and cosine values for angles, measured in
  13. **    degrees.  When you are done, free up the space used by the sine 
  14. **    storage with the FTRIG_END function.
  15. **    As in
  16. **    ftrig(FTRIG_INIT, 0); << the '0' is ignored 
  17. **    ftrig(FTRIG_SINE, 30);  
  18. **    . . .
  19. **    ftrig(FTRIG_END, 0); 
  20. **
  21. **    History:
  22. **    June 6 89, John Nalezny
  23. **    Function born
  24. */
  25.  
  26.  
  27. #include <math.h>
  28. #include <MacTypes.h>
  29. #include "ftrig.h"
  30.  
  31.  
  32. double ftrig(function, angle)
  33. int function;
  34. int angle;
  35. {
  36.   static Handle sine_cache_handle;
  37.   int loop;
  38.   int reduced_deg, neg_flag;
  39.   double *dptr;
  40. /* the BIG IDEA here is to store all the sine values we will need,
  41. ** so that we save an infinite series floating point  operation
  42. ** for each calculation.  
  43. ** Who says you need a floating point co-processor?
  44. ** Only of real interest to people with Mac Plus or lower.  Fast
  45. ** machines are fast enough so you don't care.
  46. */
  47.   
  48.   switch (function)
  49.   {
  50.       case FTRIG_INIT:    
  51.         sine_cache_handle = NewHandle( 91L * (long)sizeof(double));
  52.         HLock(sine_cache_handle); /* lock it down for the moment */
  53.         for (loop = 0; loop <= 90; loop++)
  54.         {
  55.             dptr = (double *)(*sine_cache_handle + loop * sizeof(double));
  56.             *dptr = sin((loop * PI) / 180.0);
  57.         }
  58.         HUnlock(sine_cache_handle);
  59.         break;
  60.     case FTRIG_END:
  61.         DisposHandle(sine_cache_handle);
  62.         break;
  63.     case FTRIG_COS:
  64.         angle += 90; /* then go onto the sine section */
  65.     case FTRIG_SINE:    
  66.         angle = angle % 360; /* sine is periodic, of course */
  67.         if (angle > 180)
  68.             neg_flag = TRUE;
  69.         else
  70.             neg_flag = FALSE;
  71.         angle = angle % 180; 
  72.         if( angle < 90) /* first quad */
  73.             reduced_deg = angle;
  74.         else
  75.             reduced_deg = 180 - angle;            
  76.         /* now we have a  0 <= reduced_deg <= 90 */
  77.         dptr = (double *)(*sine_cache_handle + reduced_deg * sizeof(double));
  78.         if (neg_flag)    
  79.             return(    -( *dptr) );  /* well OK, 1 floating pt. operation */
  80.         else
  81.             return( *dptr);
  82.         break; /* end of sine/cosine part */
  83.     } /* end of switch */
  84.     return(0.0); /* a normal sort of thing to return, I guess */
  85. }
  86.  
  87.